Fine-Tuning e Treinamento Próprio

1 O que é Fine-Tuning?

Pegar um modelo que já sabe muito e ensiná-lo coisas específicas do seu domínio.

Pré-treinamento vs Fine-tuning

Quando usar Fine-tuning vs RAG?

2 LoRA e QLoRA — fine-tuning eficiente

Ajustar apenas 1% dos parâmetros em vez de 100% — 10x mais barato.

🎮 Simulador: LoRA em ação

Veja como LoRA ajusta apenas uma pequena fração dos parâmetros do modelo.

A matemática do LoRA

# Forward pass com LoRA
# Em vez de:
output = x @ W  # W é a matriz de pesos original (ex: 4096 x 4096)

# LoRA faz:
output = x @ W + (x @ A) @ B * alpha

# Onde:
# W = matriz original (congelada, 4096 x 4096 = 16M parâmetros)
# A = matriz de baixa dimensão (4096 x r, treinável)
# B = matriz de baixa dimensão (r x 4096, treinável)
# r = rank (tipicamente 8, 16, 32, 64)
# alpha = fator de escala

# Com r=16:
# A: 4096 x 16 = 65.536 parâmetros
# B: 16 x 4096 = 65.536 parâmetros
# Total treinável por camada: 131.072 parâmetros
# vs W original: 16.777.216 parâmetros
# Redução: 128x menos parâmetros!

QLoRA — LoRA com quantização

3 Datasets de treinamento

A qualidade do seu dataset define a qualidade do modelo fine-tuned.

Formatos de dataset

{
  "instruction": "Classifique o ticket",
  "input": "Timeout no /v2/sync",
  "output": "prioridade_alta"
}

{
  "messages": [
    {"role": "user", "content": "..."},
    {"role": "assistant", "content": "..."}
  ]
}

{
  "prompt": "Prezado cliente,\n",
  "completion": "informamos que seu ticket..."
}

🎮 Exemplo: Dataset para suporte Nimbus Cloud

Quantos exemplos você precisa?

Boas práticas para datasets

4 Treinamento na prática

Código completo para fazer fine-tuning com QLoRA em Llama 3.

Setup do ambiente

# Instalar dependências
pip install transformers peft datasets bitsandbytes accelerate
pip install trl  # Transformer Reinforcement Learning

# Hardware recomendado:
# - QLoRA 7B: GPU com 12GB+ (RTX 3060, RTX 4070)
# - QLoRA 13B: GPU com 24GB+ (RTX 4090, A10)
# - QLoRA 70B: GPU com 48GB+ (A6000, A100 40GB)

Código completo: QLoRA em Llama 3 8B

from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_training
from trl import SFTTrainer, SFTConfig
from datasets import load_dataset
import torch

# 1. Configuração de quantização (4-bit)
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",  # Normal Float 4-bit
    bnb_4bit_compute_dtype=torch.float16,
    bnb_4bit_use_double_quant=True  # Quantização aninhada
)

# 2. Carregar modelo base quantizado
model_name = "meta-llama/Llama-3.1-8B"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    quantization_config=bnb_config,
    device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

# 3. Preparar modelo para treinamento k-bit
model = prepare_model_for_kbit_training(model)

# 4. Configuração LoRA
lora_config = LoraConfig(
    r=16,  # rank (quanto maior, mais capacidade, mais memória)
    lora_alpha=32,  # fator de escala
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],  # módulos para aplicar LoRA
    lora_dropout=0.05,
    bias="none",
    task_type="CAUSAL_LM"
)

# 5. Aplicar LoRA ao modelo
model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# trainable params: 8,388,608 || all params: 8,030,261,248 || trainable%: 0.1045

# 6. Carregar dataset
dataset = load_dataset("json", data_files="nimbus_support_dataset.json")

# 7. Configuração de treinamento
training_args = SFTConfig(
    output_dir="./nimbus-support-llama3",
    num_train_epochs=3,
    per_device_train_batch_size=2,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,  # LR típico para LoRA
    fp16=True,
    logging_steps=10,
    save_strategy="epoch",
    optim="paged_adamw_8bit",  # otimizador eficiente em memória
    max_seq_length=1024,
    warmup_ratio=0.03,
    lr_scheduler_type="cosine"
)

# 8. Criar trainer
trainer = SFTTrainer(
    model=model,
    train_dataset=dataset["train"],
    args=training_args,
    tokenizer=tokenizer
)

# 9. Treinar!
trainer.train()

# 10. Salvar adapter
model.save_pretrained("./nimbus-support-adapter")
print("✅ Treinamento concluído! Adapter salvo.")

Usando o modelo fine-tuned

from transformers import AutoModelForCausalLM, AutoTokenizer
from peft import PeftModel

# Carregar modelo base
base_model = AutoModelForCausalLM.from_pretrained(
    "meta-llama/Llama-3.1-8B",
    load_in_4bit=True,
    device_map="auto"
)
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-3.1-8B")

# Carregar adapter fine-tuned
model = PeftModel.from_pretrained(base_model, "./nimbus-support-adapter")

# Gerar resposta
prompt = "Qual o timeout do endpoint /v2/sync?"
inputs = tokenizer(prompt, return_tensors="pt").to("cuda")

outputs = model.generate(
    **inputs,
    max_new_tokens=200,
    temperature=0.3,  # baixa para precisão
    top_p=0.9
)

response = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(response)
# "O timeout padrão do endpoint /v2/sync é 30 segundos..."

Hyperparâmetros importantes

5 Avaliação de modelos fine-tuned

Como saber se o fine-tuning funcionou — métricas e testes.

Métricas de avaliação

🎮 Simulador: Comparando modelos

Veja como o modelo base se compara ao modelo fine-tuned em diferentes tarefas.

Test set — separando dados

# Dividir dataset em treino e teste
from sklearn.model_selection import train_test_split

# 80% treino, 20% teste
train_data, test_data = train_test_split(
    dataset,
    test_size=0.2,
    random_state=42
)

# Treina SÓ com train_data
trainer = SFTTrainer(
    model=model,
    train_dataset=train_data,  # ← apenas treino
    ...
)

# Avalia com test_data (modelo NUNCA viu)
def evaluate_model(model, test_data):
    correct = 0
    for example in test_data:
        prompt = example["instruction"]
        expected = example["output"]
        
        # Gera resposta
        response = generate(model, prompt)
        
        # Compara (pode ser exact match ou LLM-as-judge)
        if matches(response, expected):
            correct += 1
    
    accuracy = correct / len(test_data)
    print(f"Acurácia no test set: {accuracy:.2%}")
    return accuracy

evaluate_model(model, test_data)
# Acurácia no test set: 87.3%

Overfitting em fine-tuning

Como evitar overfitting

6 O combo RAG + Fine-tuning

O melhor dos dois mundos — quando usar cada um.

🎮 Simulador: RAG vs Fine-tuning vs Ambos

Arquitetura do combo

# Pipeline RAG + Fine-tuning

# 1. Modelo base fine-tuned para o domínio
base_model = load_model("meta-llama/Llama-3.1-8B")
model = PeftModel.from_pretrained(base_model, "./nimbus-adapter")
# ↑ Modelo já entende jargão, tom e processos da Nimbus Cloud

# 2. Usuário faz pergunta
question = "Qual o timeout do endpoint /v2/sync?"

# 3. RAG busca chunks relevantes
chunks = vector_db.search(question, top_k=5)
# ↑ Chunks atualizados dos documentos mais recentes

# 4. Monta prompt com contexto
prompt = f"""SYSTEM: Você é o Nimbus Assistant.
Responda APENAS com base no contexto. Cite fontes.

CONTEXTO:
{format_context(chunks)}

PERGUNTA: {question}"""

# 5. Modelo fine-tuned gera resposta
response = model.generate(prompt, temperature=0.2)
# ↑ Modelo entende o domínio (fine-tuning) E usa docs atualizados (RAG)

print(response)
# "O timeout padrão do endpoint /v2/sync é 30 segundos [Fonte: Docs API v3.2]."

Quando usar cada componente

7 Custos e infraestrutura

Quanto custa fazer fine-tuning — e onde rodar.

Custos estimados

Onde treinar

Inferência — rodando o modelo fine-tuned

# Opção 1: Ollama (mais simples, local)
# Converter adapter para formato GGUF
python convert_lora_to_gguf.py --adapter ./nimbus-adapter --output ./nimbus.gguf

# Rodar com Ollama
ollama run ./nimbus.gguf

# Opção 2: vLLM (alta performance, produção)
from vllm import LLM, SamplingParams

llm = LLM(
    model="meta-llama/Llama-3.1-8B",
    enable_lora=True,
    max_lora_rank=16
)
llm.lora_request = LoRARequest("nimbus", 1, "./nimbus-adapter")

outputs = llm.generate(prompts, SamplingParams(temperature=0.2))

# Opção 3: API comercial (mais caro, sem infraestrutura)
# Fine-tune via OpenAI, Anthropic ou Together AI
# Paga por token gerado, sem GPU

Checklist de produção

8 Conexão com RAG e próximos passos

Como fine-tuning completa o pipeline RAG — e o que vem depois.

Evolução completa do curso

O sistema final da Nimbus Cloud

# Arquitetura completa

# 1. Usuário faz pergunta (texto, áudio ou imagem)
input = get_user_input()

# 2. Se for áudio, transcreve (Whisper)
if is_audio(input):
    input = whisper.transcribe(input)

# 3. Se for imagem, extrai descrição (LLM multimodal)
if is_image(input):
    input = llava.describe(input)

# 4. RAG busca chunks relevantes
chunks = vector_db.search(input, top_k=5)

# 5. Agent decide se precisa buscar mais
if agent.needs_more_info(chunks):
    chunks += agent.search_more(input)

# 6. Monta prompt com contexto
prompt = build_prompt(chunks, input)

# 7. Modelo fine-tuned gera resposta
response = fine_tuned_model.generate(prompt)

# 8. Opcional: converte resposta em áudio (TTS)
if user_wants_audio():
    response = piper.tts(response)

# 9. Retorna resposta ao usuário
send_response(response)

# 10. Log tudo para observabilidade
langfuse.trace(input, chunks, prompt, response)

O que você construiu ao longo do curso

🎯 Quiz — teste seu conhecimento

Clique em uma alternativa para ver se acertou.

→ O que vem a seguir?

Agora que você sabe treinar modelos, vamos aprender a colocá-los em produção de forma robusta.

Conceitos que vamos construir aqui